require('dotenv').config();
const jwt = require('jsonwebtoken');

// 身份验证中间件 - 验证用户是否已登录
const protect = (req, res, next) => {
    const authHeader = req.headers['authorization'];
    console.log('[AUTH] 收到的Authorization头:', authHeader);
    
    if (!authHeader) {
        console.log('[AUTH] 未提供授权令牌');
        return res.status(401).json({ 
            code: 401,
            message: '未提供授权令牌' 
        });
    }

    // 支持 Bearer 前缀和直接token两种格式
    const token = authHeader.startsWith('Bearer ') ? authHeader.split(' ')[1] : authHeader;
    console.log('[AUTH] 提取的token:', token.substring(0, 20) + '...');
    
    try {
        console.log('[AUTH] 开始验证token');
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        console.log('[AUTH] Token解析结果:', {
            id: decoded.id,
            userId: decoded.userId,
            role: decoded.role,
            phone: decoded.phone,
            iat: decoded.iat,
            exp: decoded.exp
        });

        // 确保必要的用户信息存在
        const userId = decoded.userId || decoded.id;
        if (!userId) {
            console.error('[AUTH] Token中缺少用户ID');
            return res.status(401).json({
                code: 401,
                message: '无效的授权令牌：缺少用户信息'
            });
        }

        // 设置用户信息
        req.user = {
            userId: userId,
            role: decoded.role,
            phone: decoded.phone
        };

        console.log('[AUTH] 用户信息设置成功:', req.user);
        next();
    } catch (error) {
        console.error('[AUTH] Token验证失败:', error);
        if (error.name === 'TokenExpiredError') {
            return res.status(401).json({ 
                code: 401,
                message: '登录已过期，请重新登录' 
            });
        }
        if (error.name === 'JsonWebTokenError') {
            return res.status(401).json({ 
                code: 401,
                message: '无效的授权令牌：' + error.message 
            });
        }
        res.status(401).json({ 
            code: 401,
            message: '无效的授权令牌' 
        });
    }
};

// 基于角色的权限控制中间件
const restrictTo = (...roles) => {
    return (req, res, next) => {
        console.log('[AUTH] 检查角色权限:', {
            userRole: req.user?.role,
            requiredRoles: roles
        });

        if (!req.user) {
            console.error('[AUTH] 用户信息不存在');
            return res.status(401).json({
                code: 401,
                message: '未登录'
            });
        }

        if (roles.includes(req.user.role)) {
            console.log('[AUTH] 角色权限验证通过');
            next();
        } else {
            console.error('[AUTH] 权限不足:', {
                userRole: req.user.role,
                requiredRoles: roles
            });
            res.status(403).json({ 
                code: 403,
                message: '权限不足：需要 ' + roles.join(' 或 ') + ' 角色权限' 
            });
        }
    };
};

// 管理员权限中间件 - 验证用户是否有管理员权限
const adminOnly = (req, res, next) => {
    console.log('[AUTH] 检查管理员权限:', req.user);
    if (!req.user) {
        console.error('[AUTH] 用户信息不存在');
        return res.status(401).json({
            code: 401,
            message: '未登录'
        });
    }

    if (req.user.role === 'super' || req.user.role === 'store') {
        console.log('[AUTH] 管理员权限验证通过');
        next();
    } else {
        console.error('[AUTH] 权限不足:', req.user.role);
        res.status(403).json({ 
            code: 403,
            message: '权限不足：需要管理员权限' 
        });
    }
};

// 超级管理员权限中间件 - 验证用户是否有超级管理员权限
const superAdminOnly = (req, res, next) => {
    console.log('[AUTH] 检查超级管理员权限:', {
        userId: req.user?.userId,
        role: req.user?.role,
        phone: req.user?.phone
    });
    
    if (!req.user) {
        console.error('[AUTH] 用户信息不存在');
        return res.status(401).json({
            code: 401,
            message: '未登录'
        });
    }

    if (req.user.role === 'super') {
        console.log('[AUTH] 超级管理员权限验证通过');
        next();
    } else {
        console.error('[AUTH] 权限不足:', {
            expectedRole: 'super',
            actualRole: req.user.role
        });
        res.status(403).json({ 
            code: 403,
            message: '权限不足：需要超级管理员权限' 
        });
    }
};

// 商家申请中间件 - 允许普通用户和商家角色访问
const merchantApplyAccess = (req, res, next) => {
    const authHeader = req.headers['authorization'];
    console.log('[AUTH] 商家申请 - 收到的Authorization头:', authHeader);
    
    if (!authHeader) {
        console.log('[AUTH] 商家申请 - 未提供授权令牌');
        return res.status(401).json({ 
            code: 401,
            message: '未提供授权令牌' 
        });
    }

    // 支持 Bearer 前缀和直接token两种格式
    const token = authHeader.startsWith('Bearer ') ? authHeader.split(' ')[1] : authHeader;
    console.log('[AUTH] 商家申请 - 提取的token:', token.substring(0, 20) + '...');
    
    try {
        console.log('[AUTH] 商家申请 - 开始验证token');
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        console.log('[AUTH] 商家申请 - Token解析结果:', {
            id: decoded.id,
            userId: decoded.userId,
            role: decoded.role,
            phone: decoded.phone,
            iat: decoded.iat,
            exp: decoded.exp
        });

        // 确保必要的用户信息存在
        const userId = decoded.userId || decoded.id;
        if (!userId) {
            console.error('[AUTH] 商家申请 - Token中缺少用户ID');
            return res.status(401).json({
                code: 401,
                message: '无效的授权令牌：缺少用户信息'
            });
        }

        // 设置用户信息
        req.user = {
            userId: userId,
            role: decoded.role || 'user', // 如果角色不存在，默认为user
            phone: decoded.phone
        };

        console.log('[AUTH] 商家申请 - 用户信息设置成功:', req.user);
        
        // 对于商家申请接口，允许任何有效token访问
        console.log('[AUTH] 商家申请权限验证通过, 角色:', req.user.role);
        next();
    } catch (error) {
        console.error('[AUTH] 商家申请 - Token验证失败:', error);
        if (error.name === 'TokenExpiredError') {
            return res.status(401).json({ 
                code: 401,
                message: '登录已过期，请重新登录' 
            });
        }
        if (error.name === 'JsonWebTokenError') {
            return res.status(401).json({ 
                code: 401,
                message: '无效的授权令牌：' + error.message 
            });
        }
        res.status(401).json({ 
            code: 401,
            message: '无效的授权令牌' 
        });
    }
};

// 向后兼容旧代码
const authMiddleware = protect;
const isSuperAdmin = superAdminOnly;

module.exports = { 
    protect, 
    adminOnly, 
    superAdminOnly,
    merchantApplyAccess,
    restrictTo,
    // 向后兼容
    authMiddleware, 
    isSuperAdmin 
};